﻿Imports Microsoft.DirectX
Imports Microsoft.DirectX.Direct3D
Imports Commander_Wars.Spieletools
Public MustInherit Class ObjektLandschaftsTextur
    Public Enum Positionsarten
        Boden
        Luft
        Wasser
    End Enum

    Private IDD As String
    Public Property ID() As String
        Get
            Return IDD
        End Get
        Set(ByVal value As String)
            IDD = value
        End Set
    End Property
    Public Landschaftsname As String
    Public Deckung As Integer = 0
    Public Tarnung As Boolean = False
    Public KP As Integer = -1
    Public Texturen() As Texture = {}
    Protected Ausrichtung() As String = {}
    Protected Normal As Integer
    Protected Ausrichtungslandschaften() As String = {}
    Public Übergänge() As Texture = {}
    Public Übergangfunktion() As String = {}
    Public ÜbergangsModus As Übergangsmodi = Übergangsmodi.Keiner
    Dim ÜbergangsAusrichtungslandschaften() As String = {}
    Public WirdZu As String
    Public Groß As Boolean = False
    Public Frame As Boolean = False
    Public Shared WüstenID As Integer = -1
    Public Shared EbenenID As Integer = -1
    Public Shared SeeID As Integer = -1
    Public Shared SchneeID As Integer = -1

    Enum Übergangsmodi
        Keiner
        VierAngrenzenden
        NichtVierAngrenzenden
        NurEcken
        NichtNurEcken
        Strand
    End Enum

    Protected Sub TexturenLaden(ByVal Bilder() As String)
        Dim Ordner As String =ObjektLadeklasse.GetOrdner
        For Each Bild In Bilder

            Array.Resize(Texturen, Texturen.Length + 1)
            Array.Resize(Ausrichtung, Ausrichtung.Length + 1)
            If My.Computer.FileSystem.FileExists(My.Settings.Resourcenpfad + "Landschaften\Bilder\" + Ordner + Bild + ".png") Then
                Texturen(Texturen.Length - 1) = Grafikengine.LoadTexture(My.Settings.Resourcenpfad + "Landschaften\Bilder\" + Ordner + Bild + ".png")
            Else
                Texturen(Texturen.Length - 1) = Grafikengine.LoadTexture(My.Settings.Resourcenpfad + "Landschaften\Bilder\CW\" + Bild + ".png")
            End If
            Dim Name() As String = Bild.Split("+")
            If Name.Length > 1 Then
                If IsNumeric(Name(1)) = False Then
                    Dim Namen As String = ""
                    For I = 1 To Name.Length - 1
                        Namen += Name(I)
                        If I >= Name.Length - 1 Then
                            Ausrichtung(Ausrichtung.Length - 1) = Namen
                            Exit For
                        End If
                        Namen += "+"
                    Next
                End If
            End If
        Next
    End Sub
#Region "Spezial Malen"
    Public Overridable Function DrawSpecialStyle(ByVal BildID As Integer, ByVal Fog As Nebelarten, ByVal Alpha As Integer, ByVal X As Integer, ByVal Y As Integer) As Boolean
        Return False
    End Function
    Protected Function DrawSeeUndTerrain(ByVal Alpha As Integer, ByVal Kriegsnebel As Nebelarten, ByVal BildId As Integer, ByVal X As Integer, ByVal Y As Integer, ByVal Frames As Integer) As Boolean
        Dim sngRotation As Double = 0
        Dim intColor As Color = Color.FromArgb(Alpha, 255, 255, 255)
        'prüfen ob wir aus den Screenbereich laufen
        Select Case Kriegsnebel
            Case Nebelarten.Nebel
                intColor = Color.FromArgb(Alpha, 180, 180, 180)
            Case Nebelarten.Kriegsnebel
                intColor = Color.FromArgb(Alpha, 120, 120, 120)
        End Select
        'Zuerst See Malen
        With Grafikengine.recBild
            .X = 0 : .Width = Hauptmenü.Feldbreite
            .Y = 0 : .Height = Hauptmenü.Feldbreite
        End With
        With Grafikengine.ptfRotCenter
            .X = Hauptmenü.Feldbreite / 2
            .Y = Hauptmenü.Feldbreite / 2
        End With
        With Grafikengine.szfScale
            .Height = Hauptmenü.Feldbreite
            .Width = Hauptmenü.Feldbreite
        End With
        If Objektverwalter.LandschaftenBilder(SeeID).Frame Then
            Grafikengine.recBild.X += ObjektLandschaft.Frame * Hauptmenü.Feldbreite
        End If
        Grafikengine.ptfPosition = New Drawing.Point(Hauptmenü.Feldbreite * X + Objektverwalter.Spielfeld.BildschirmKooX, Hauptmenü.Feldbreite * Y + Objektverwalter.Spielfeld.BildschirmKooY)
        Grafikengine.Sprite.Draw2D(Objektverwalter.LandschaftenBilder(SeeID).Texturen(0), Grafikengine.recBild, Grafikengine.szfScale, Grafikengine.ptfRotCenter, sngRotation, Grafikengine.ptfPosition, intColor)

        If Groß = False Then
            With Grafikengine.recBild
                .X = 0 : .Width = Hauptmenü.Feldbreite
                .Y = 0 : .Height = Hauptmenü.Feldbreite
            End With
            With Grafikengine.ptfRotCenter
                .X = Hauptmenü.Feldbreite / 2
                .Y = Hauptmenü.Feldbreite / 2
            End With
            With Grafikengine.szfScale
                .Height = Hauptmenü.Feldbreite
                .Width = Hauptmenü.Feldbreite
            End With
        Else
            With Grafikengine.recBild
                .X = 0 : .Width = Hauptmenü.Feldbreite
                .Y = 0 : .Height = Hauptmenü.Feldbreite * 2
            End With
            With Grafikengine.ptfRotCenter
                .X = Hauptmenü.Feldbreite / 2
                .Y = Hauptmenü.Feldbreite / 2 + Hauptmenü.Feldbreite
            End With
            With Grafikengine.szfScale
                .Height = Hauptmenü.Feldbreite * 2
                .Width = Hauptmenü.Feldbreite
            End With
        End If

        Grafikengine.recBild.X += Frames * Hauptmenü.Feldbreite
        Grafikengine.Sprite.Draw2D(Texturen(BildId), Grafikengine.recBild, Grafikengine.szfScale, Grafikengine.ptfRotCenter, sngRotation, Grafikengine.ptfPosition, intColor)
        Return True
    End Function
    Protected Function DrawEbeneUndTerrain(ByVal Alpha As Integer, ByVal Kriegsnebel As Nebelarten, ByVal BildId As Integer, ByVal X As Integer, ByVal Y As Integer, ByVal Frames As Integer) As Boolean
        Dim sngRotation As Double = 0
        Dim intColor As Color = Color.FromArgb(Alpha, 255, 255, 255)
        'prüfen ob wir aus den Screenbereich laufen
        Select Case Kriegsnebel
            Case Nebelarten.Nebel
                intColor = Color.FromArgb(Alpha, 180, 180, 180)
            Case Nebelarten.Kriegsnebel
                intColor = Color.FromArgb(Alpha, 120, 120, 120)
        End Select
        'Zuerst See Malen
        With Grafikengine.recBild
            .X = 0 : .Width = Hauptmenü.Feldbreite
            .Y = 0 : .Height = Hauptmenü.Feldbreite
        End With
        With Grafikengine.ptfRotCenter
            .X = Hauptmenü.Feldbreite / 2
            .Y = Hauptmenü.Feldbreite / 2
        End With
        With Grafikengine.szfScale
            .Height = Hauptmenü.Feldbreite
            .Width = Hauptmenü.Feldbreite
        End With
        If Objektverwalter.LandschaftenBilder(EbenenID).Frame Then
            Grafikengine.recBild.X += ObjektLandschaft.Frame * Hauptmenü.Feldbreite
        End If
        Grafikengine.ptfPosition = New Drawing.Point(Hauptmenü.Feldbreite * X + Objektverwalter.Spielfeld.BildschirmKooX, Hauptmenü.Feldbreite * Y + Objektverwalter.Spielfeld.BildschirmKooY)
        Grafikengine.Sprite.Draw2D(Objektverwalter.LandschaftenBilder(EbenenID).Texturen(0), Grafikengine.recBild, Grafikengine.szfScale, Grafikengine.ptfRotCenter, sngRotation, Grafikengine.ptfPosition, intColor)

        If Groß = False Then
            With Grafikengine.recBild
                .X = 0 : .Width = Hauptmenü.Feldbreite
                .Y = 0 : .Height = Hauptmenü.Feldbreite
            End With
            With Grafikengine.ptfRotCenter
                .X = Hauptmenü.Feldbreite / 2
                .Y = Hauptmenü.Feldbreite / 2
            End With
            With Grafikengine.szfScale
                .Height = Hauptmenü.Feldbreite
                .Width = Hauptmenü.Feldbreite
            End With
        Else
            With Grafikengine.recBild
                .X = 0 : .Width = Hauptmenü.Feldbreite
                .Y = 0 : .Height = Hauptmenü.Feldbreite * 2
            End With
            With Grafikengine.ptfRotCenter
                .X = Hauptmenü.Feldbreite / 2
                .Y = Hauptmenü.Feldbreite / 2 + Hauptmenü.Feldbreite
            End With
            With Grafikengine.szfScale
                .Height = Hauptmenü.Feldbreite * 2
                .Width = Hauptmenü.Feldbreite
            End With
        End If
        Grafikengine.recBild.X += Frames * Hauptmenü.Feldbreite
        Grafikengine.Sprite.Draw2D(Texturen(BildId), Grafikengine.recBild, Grafikengine.szfScale, Grafikengine.ptfRotCenter, sngRotation, Grafikengine.ptfPosition, intColor)
        Return True
    End Function
    Protected Function DrawWüsteUndTerrain(ByVal Alpha As Integer, ByVal Kriegsnebel As Nebelarten, ByVal BildId As Integer, ByVal X As Integer, ByVal Y As Integer, ByVal Frames As Boolean) As Boolean
        Dim sngRotation As Double = 0
        Dim intColor As Color = Color.FromArgb(Alpha, 255, 255, 255)
        'prüfen ob wir aus den Screenbereich laufen
        Select Case Kriegsnebel
            Case Nebelarten.Nebel
                intColor = Color.FromArgb(Alpha, 180, 180, 180)
            Case Nebelarten.Kriegsnebel
                intColor = Color.FromArgb(Alpha, 120, 120, 120)
        End Select
        'Zuerst See Malen
        With Grafikengine.recBild
            .X = 0 : .Width = Hauptmenü.Feldbreite
            .Y = 0 : .Height = Hauptmenü.Feldbreite
        End With
        With Grafikengine.ptfRotCenter
            .X = Hauptmenü.Feldbreite / 2
            .Y = Hauptmenü.Feldbreite / 2
        End With
        With Grafikengine.szfScale
            .Height = Hauptmenü.Feldbreite
            .Width = Hauptmenü.Feldbreite
        End With
        If Objektverwalter.LandschaftenBilder(WüstenID).Frame Then
            Grafikengine.recBild.X += ObjektLandschaft.Frame * Hauptmenü.Feldbreite
        End If
        Grafikengine.ptfPosition = New Drawing.Point(Hauptmenü.Feldbreite * X + Objektverwalter.Spielfeld.BildschirmKooX, Hauptmenü.Feldbreite * Y + Objektverwalter.Spielfeld.BildschirmKooY)
        Grafikengine.Sprite.Draw2D(Objektverwalter.LandschaftenBilder(WüstenID).Texturen(0), Grafikengine.recBild, Grafikengine.szfScale, Grafikengine.ptfRotCenter, sngRotation, Grafikengine.ptfPosition, intColor)

        If Groß = False Then
            With Grafikengine.recBild
                .X = 0 : .Width = Hauptmenü.Feldbreite
                .Y = 0 : .Height = Hauptmenü.Feldbreite
            End With
            With Grafikengine.ptfRotCenter
                .X = Hauptmenü.Feldbreite / 2
                .Y = Hauptmenü.Feldbreite / 2
            End With
            With Grafikengine.szfScale
                .Height = Hauptmenü.Feldbreite
                .Width = Hauptmenü.Feldbreite
            End With
        Else
            With Grafikengine.recBild
                .X = 0 : .Width = Hauptmenü.Feldbreite
                .Y = 0 : .Height = Hauptmenü.Feldbreite * 2
            End With
            With Grafikengine.ptfRotCenter
                .X = Hauptmenü.Feldbreite / 2
                .Y = Hauptmenü.Feldbreite / 2 + Hauptmenü.Feldbreite
            End With
            With Grafikengine.szfScale
                .Height = Hauptmenü.Feldbreite * 2
                .Width = Hauptmenü.Feldbreite
            End With
        End If
        If Frames Then
            Grafikengine.recBild.X += ObjektLandschaft.Frame * Hauptmenü.Feldbreite
        End If
        Grafikengine.Sprite.Draw2D(Texturen(BildId), Grafikengine.recBild, Grafikengine.szfScale, Grafikengine.ptfRotCenter, sngRotation, Grafikengine.ptfPosition, intColor)
        Return True
    End Function
    Protected Function DrawSchneeUndTerrain(ByVal Alpha As Integer, ByVal Kriegsnebel As Nebelarten, ByVal BildId As Integer, ByVal X As Integer, ByVal Y As Integer, ByVal Frames As Boolean) As Boolean
        Dim sngRotation As Double = 0
        Dim intColor As Color = Color.FromArgb(Alpha, 255, 255, 255)
        'prüfen ob wir aus den Screenbereich laufen
        Select Case Kriegsnebel
            Case Nebelarten.Nebel
                intColor = Color.FromArgb(Alpha, 180, 180, 180)
            Case Nebelarten.Kriegsnebel
                intColor = Color.FromArgb(Alpha, 120, 120, 120)
        End Select
        'Zuerst See Malen
        With Grafikengine.recBild
            .X = 0 : .Width = Hauptmenü.Feldbreite
            .Y = 0 : .Height = Hauptmenü.Feldbreite
        End With
        With Grafikengine.ptfRotCenter
            .X = Hauptmenü.Feldbreite / 2
            .Y = Hauptmenü.Feldbreite / 2
        End With
        With Grafikengine.szfScale
            .Height = Hauptmenü.Feldbreite
            .Width = Hauptmenü.Feldbreite
        End With
        If Objektverwalter.LandschaftenBilder(SchneeID).Frame Then
            Grafikengine.recBild.X += ObjektLandschaft.Frame * Hauptmenü.Feldbreite
        End If
        Grafikengine.ptfPosition = New Drawing.Point(Hauptmenü.Feldbreite * X + Objektverwalter.Spielfeld.BildschirmKooX, Hauptmenü.Feldbreite * Y + Objektverwalter.Spielfeld.BildschirmKooY)
        Grafikengine.Sprite.Draw2D(Objektverwalter.LandschaftenBilder(SchneeID).Texturen(0), Grafikengine.recBild, Grafikengine.szfScale, Grafikengine.ptfRotCenter, sngRotation, Grafikengine.ptfPosition, intColor)

        If Groß = False Then
            With Grafikengine.recBild
                .X = 0 : .Width = Hauptmenü.Feldbreite
                .Y = 0 : .Height = Hauptmenü.Feldbreite
            End With
            With Grafikengine.ptfRotCenter
                .X = Hauptmenü.Feldbreite / 2
                .Y = Hauptmenü.Feldbreite / 2
            End With
            With Grafikengine.szfScale
                .Height = Hauptmenü.Feldbreite
                .Width = Hauptmenü.Feldbreite
            End With
        Else
            With Grafikengine.recBild
                .X = 0 : .Width = Hauptmenü.Feldbreite
                .Y = 0 : .Height = Hauptmenü.Feldbreite * 2
            End With
            With Grafikengine.ptfRotCenter
                .X = Hauptmenü.Feldbreite / 2
                .Y = Hauptmenü.Feldbreite / 2 + Hauptmenü.Feldbreite
            End With
            With Grafikengine.szfScale
                .Height = Hauptmenü.Feldbreite * 2
                .Width = Hauptmenü.Feldbreite
            End With
        End If
        If Frames Then
            Grafikengine.recBild.X += ObjektLandschaft.Frame * Hauptmenü.Feldbreite
        End If
        Grafikengine.Sprite.Draw2D(Texturen(BildId), Grafikengine.recBild, Grafikengine.szfScale, Grafikengine.ptfRotCenter, sngRotation, Grafikengine.ptfPosition, intColor)
        Return True
    End Function
#End Region
#Region "Übergänge"
    Protected Sub ÜbergängeLaden(ByVal Übergang As String)
        Select Case Übergang.ToUpper
            Case "FLUSSMÜNDUNG"
                Flussmündung()
            Case "SCHNEE"
                Schnee()
            Case "WÜSTE"
                Wüste()
            Case "STRAND"
                Strand()
            Case "KÜSTE"
                Küste()
            Case "SUMPF"
                Sumpf()
            Case "BRÜCKE"
                DCBrücke()
        End Select
    End Sub
    ''' <summary>
    ''' Lädt den Übergang Flussmündung
    ''' </summary>
    ''' <remarks></remarks>
    Private Sub Flussmündung()
        ÜbergangsModus = Übergangsmodi.VierAngrenzenden
        ÜbergangsAusrichtungslandschaften = New String() {"SEE", "RIFF", "RAUESEE", "NEBEL"}
        Array.Resize(Übergänge, 4)
        Dim Ordner As String = ObjektLadeklasse.GetOrdner
        If Not My.Computer.FileSystem.FileExists(My.Settings.Resourcenpfad + "Landschaften\Übergänge\" + Ordner + "Flussmündung+S.png") Then Ordner = "CW\"
        Übergänge(0) = Grafikengine.LoadTexture(My.Settings.Resourcenpfad + "Landschaften\Übergänge\" + Ordner + "Flussmündung+S.png")
        Übergänge(1) = Grafikengine.LoadTexture(My.Settings.Resourcenpfad + "Landschaften\Übergänge\" + Ordner + "Flussmündung+N.png")
        Übergänge(2) = Grafikengine.LoadTexture(My.Settings.Resourcenpfad + "Landschaften\Übergänge\" + Ordner + "Flussmündung+O.png")
        Übergänge(3) = Grafikengine.LoadTexture(My.Settings.Resourcenpfad + "Landschaften\Übergänge\" + Ordner + "Flussmündung+W.png")
        Übergangfunktion = New String() {"S", "N", "O", "W"}
    End Sub
    ''' <summary>
    ''' Lädt den Übergang Wüste
    ''' </summary>
    ''' <remarks></remarks>
    Private Sub Wüste()
        Dim Ordner As String = ObjektLadeklasse.GetOrdner
        ÜbergangsModus = Übergangsmodi.VierAngrenzenden
        ÜbergangsAusrichtungslandschaften = New String() {"EBENE", "EBENE+SCHROTT", "STRAßE", "SUMPF"}
        Array.Resize(Übergänge, 4)
        If Not My.Computer.FileSystem.FileExists(My.Settings.Resourcenpfad + "Landschaften\Übergänge\" + Ordner + "Wüste+S.png") Then Ordner = "CW\"
        Übergänge(0) = Grafikengine.LoadTexture(My.Settings.Resourcenpfad + "Landschaften\Übergänge\" + Ordner + "Wüste+S.png")
        Übergänge(1) = Grafikengine.LoadTexture(My.Settings.Resourcenpfad + "Landschaften\Übergänge\" + Ordner + "Wüste+N.png")
        Übergänge(2) = Grafikengine.LoadTexture(My.Settings.Resourcenpfad + "Landschaften\Übergänge\" + Ordner + "Wüste+O.png")
        Übergänge(3) = Grafikengine.LoadTexture(My.Settings.Resourcenpfad + "Landschaften\Übergänge\" + Ordner + "Wüste+W.png")
        Übergangfunktion = New String() {"S", "N", "O", "W"}
    End Sub
    ''' <summary>
    ''' Lädt den Übergang Wüste
    ''' </summary>
    ''' <remarks></remarks>
    Private Sub Strand()
        Dim Ordner As String = ObjektLadeklasse.GetOrdner
        ÜbergangsModus = Übergangsmodi.Strand
        ÜbergangsAusrichtungslandschaften = New String() {"EBENE", "LASER", "PLASMA", "FEUER", "METEOR", "ÖDLAND", "RUINE", "SUMPF", "WALD", "BERG", "STRAßE", "WÜSTE", "PIPELINE", "EBENE+SCHROTT", "HQ", "STADT", "BASIS", "WERFT", "FLUGHAFEN", "FABRIK", "TURM", "SCHWEIßNAHT", "KRISTALL", "MONOLITH", "MAUER", "PIPE", "PIPESCHWEIß", "KAPUTTEPIPESCHWEIß", "KAPUTTESCHWEIßNAHT", "KAKTEEN", "FELSEN", "AUSGETROCKNETESFLUSSBETT", "PFAD", "MINIGESCHÜTZ+N", "MINIGESCHÜTZ+O", "MINIGESCHÜTZ+S", "MINIGESCHÜTZ+W", "SCHWARZE GESCHÜTZ+N", "SCHWARZE GESCHÜTZ+O", "SCHWARZE GESCHÜTZ+S", "SCHWARZE GESCHÜTZ+W", "VULKAN", "FESTUNG", "OMEGARAKETE", "MINE", "WÜSTE+SCHROTT", "SCHNEE+SCHROTT", "RAKETENSILO+RAKETE", "RAKETENSILO", "SCHNEE", "KIEFERN", "GIPFEL", "STRAßENFROST", "PLINEKAPUTT", "PLINE", "PLINESCHWEIß", "PIPESTATION", "SCHOCKLASER+N", "SCHOCKLASER+O", "SCHOCKLASER+S", "SCHOCKLASER+W"}
        Array.Resize(Übergänge, 8)
        If Not My.Computer.FileSystem.FileExists(My.Settings.Resourcenpfad + "Landschaften\Übergänge\" + Ordner + "Strand+NW.png") Then Ordner = "CW\"
        Übergänge(0) = Grafikengine.LoadTexture(My.Settings.Resourcenpfad + "Landschaften\Übergänge\" + Ordner + "Strand+NW.png")
        Übergänge(1) = Grafikengine.LoadTexture(My.Settings.Resourcenpfad + "Landschaften\Übergänge\" + Ordner + "Strand+NO.png")
        Übergänge(2) = Grafikengine.LoadTexture(My.Settings.Resourcenpfad + "Landschaften\Übergänge\" + Ordner + "Strand+SO.png")
        Übergänge(3) = Grafikengine.LoadTexture(My.Settings.Resourcenpfad + "Landschaften\Übergänge\" + Ordner + "Strand+SW.png")
        Übergänge(4) = Grafikengine.LoadTexture(My.Settings.Resourcenpfad + "Landschaften\Übergänge\" + Ordner + "Strand+ON.png")
        Übergänge(5) = Grafikengine.LoadTexture(My.Settings.Resourcenpfad + "Landschaften\Übergänge\" + Ordner + "Strand+OS.png")
        Übergänge(6) = Grafikengine.LoadTexture(My.Settings.Resourcenpfad + "Landschaften\Übergänge\" + Ordner + "Strand+WS.png")
        Übergänge(7) = Grafikengine.LoadTexture(My.Settings.Resourcenpfad + "Landschaften\Übergänge\" + Ordner + "Strand+WN.png")
        Übergangfunktion = New String() {"NW", "NO", "SO", "SW", "ON", "OS", "WS", "WN"}
    End Sub
    ''' <summary>
    ''' Lädt den Übergang Küste
    ''' </summary>
    ''' <remarks></remarks>
    Private Sub Küste()
        Dim Ordner As String = ObjektLadeklasse.GetOrdner
        ÜbergangsModus = Übergangsmodi.NichtNurEcken
        ÜbergangsAusrichtungslandschaften = New String() {"SEE", "RIFF", "STRAND", "BRÜCKE", "ZUGBRÜCKE", "BAUBRÜCKE", "RAUESEE", "NEBEL"}
        Array.Resize(Übergänge, 4)
        If Not My.Computer.FileSystem.FileExists(My.Settings.Resourcenpfad + "Landschaften\Übergänge\" + Ordner + "Küste+NW.png") Then Ordner = "CW\"
        Übergänge(0) = Grafikengine.LoadTexture(My.Settings.Resourcenpfad + "Landschaften\Übergänge\" + Ordner + "Küste+NO.png")
        Übergänge(1) = Grafikengine.LoadTexture(My.Settings.Resourcenpfad + "Landschaften\Übergänge\" + Ordner + "Küste+NW.png")
        Übergänge(2) = Grafikengine.LoadTexture(My.Settings.Resourcenpfad + "Landschaften\Übergänge\" + Ordner + "Küste+SW.png")
        Übergänge(3) = Grafikengine.LoadTexture(My.Settings.Resourcenpfad + "Landschaften\Übergänge\" + Ordner + "Küste+OS.png")
        Übergangfunktion = New String() {"NO", "NW", "SW", "OS"}
    End Sub
    ''' <summary>
    ''' Lädt den Übergang Schnee
    ''' </summary>
    ''' <remarks></remarks>
    Private Sub Schnee()
        Dim Ordner As String = ObjektLadeklasse.GetOrdner
        ÜbergangsModus = Übergangsmodi.VierAngrenzenden
        ÜbergangsAusrichtungslandschaften = New String() {"EBENE", "SUMPF", "EBENE+SCHROTT", "STRAßE", "WÜSTE", "PFAD", "WÜSTE+SCHROTT"}
        Array.Resize(Übergänge, 4)
        If Not My.Computer.FileSystem.FileExists(My.Settings.Resourcenpfad + "Landschaften\Übergänge\" + Ordner + "Schnee+S.png") Then Ordner = "CW\"
        Übergänge(0) = Grafikengine.LoadTexture(My.Settings.Resourcenpfad + "Landschaften\Übergänge\" + Ordner + "Schnee+S.png")
        Übergänge(1) = Grafikengine.LoadTexture(My.Settings.Resourcenpfad + "Landschaften\Übergänge\" + Ordner + "Schnee+N.png")
        Übergänge(2) = Grafikengine.LoadTexture(My.Settings.Resourcenpfad + "Landschaften\Übergänge\" + Ordner + "Schnee+O.png")
        Übergänge(3) = Grafikengine.LoadTexture(My.Settings.Resourcenpfad + "Landschaften\Übergänge\" + Ordner + "Schnee+W.png")
        Übergangfunktion = New String() {"S", "N", "O", "W"}
    End Sub
    ''' <summary>
    ''' Lädt den Übergang Sumpf
    ''' </summary>
    ''' <remarks></remarks>
    Private Sub Sumpf()
        Dim Ordner As String = ObjektLadeklasse.GetOrdner
        ÜbergangsModus = Übergangsmodi.VierAngrenzenden
        ÜbergangsAusrichtungslandschaften = New String() {"EBENE", "EBENE+SCHROTT", "STRAßE"}
        Array.Resize(Übergänge, 4)
        If Not My.Computer.FileSystem.FileExists(My.Settings.Resourcenpfad + "Landschaften\Übergänge\" + Ordner + "SUMPF+S.png") Then Ordner = "CW\"
        Übergänge(0) = Grafikengine.LoadTexture(My.Settings.Resourcenpfad + "Landschaften\Übergänge\" + Ordner + "SUMPF+S.png")
        Übergänge(1) = Grafikengine.LoadTexture(My.Settings.Resourcenpfad + "Landschaften\Übergänge\" + Ordner + "SUMPF+N.png")
        Übergänge(2) = Grafikengine.LoadTexture(My.Settings.Resourcenpfad + "Landschaften\Übergänge\" + Ordner + "SUMPF+O.png")
        Übergänge(3) = Grafikengine.LoadTexture(My.Settings.Resourcenpfad + "Landschaften\Übergänge\" + Ordner + "SUMPF+W.png")
        Übergangfunktion = New String() {"S", "N", "O", "W"}
    End Sub
    ''' <summary>
    ''' Lädt die Brücke für Darc Conflict Version
    ''' </summary>
    ''' <remarks></remarks>
    Private Sub DCBrücke()
        ÜbergangsModus = Übergangsmodi.NichtVierAngrenzenden
        ÜbergangsAusrichtungslandschaften = New String() {"SEE", "NEBEL", "STRAND", "RIFF", "RAUE SEE", "BRÜCKE", "ZUGBRÜCKE", "BAUBRÜCKE"}
        Array.Resize(Übergänge, 4)
        Dim Ordner As String = ObjektLadeklasse.GetOrdner
        If Not My.Computer.FileSystem.FileExists(My.Settings.Resourcenpfad + "Landschaften\Übergänge\" + Ordner + "Brücke+S.png") Then Ordner = "CW\"
        Übergänge(0) = Grafikengine.LoadTexture(My.Settings.Resourcenpfad + "Landschaften\Übergänge\" + Ordner + "Brücke+S.png")
        Übergänge(1) = Grafikengine.LoadTexture(My.Settings.Resourcenpfad + "Landschaften\Übergänge\" + Ordner + "Brücke+N.png")
        Übergänge(2) = Grafikengine.LoadTexture(My.Settings.Resourcenpfad + "Landschaften\Übergänge\" + Ordner + "Brücke+O.png")
        Übergänge(3) = Grafikengine.LoadTexture(My.Settings.Resourcenpfad + "Landschaften\Übergänge\" + Ordner + "Brücke+W.png")
        Übergangfunktion = New String() {"S", "N", "O", "W"}
    End Sub
#End Region

    ''' <summary>
    ''' Ist jetzt eine Extra funktion, die nur das "+N+S+W" usw. zurückgibt, damit ichs fürs 3D verwenden kann.
    ''' </summary>
    ''' <param name="X"></param>
    ''' <param name="Y"></param>
    ''' <param name="Spielfeld"></param>
    ''' <returns></returns>
    ''' <remarks></remarks>
    Public Function getAusrichtung(ByVal X As Integer, ByVal Y As Integer, ByVal Spielfeld As ObjektSpielfeld) As String
        Dim Ausrichtungen As String = ""
        If IsNothing(Spielfeld) = False And Not Spielfeld.Landschaften(Spielfeld.Breite - 1, Spielfeld.Höhe - 1, ObjektSpielfeld.Bodenschlacht) Is Nothing Then
            If Y - 1 >= 0 Then
                If FindElement(Ausrichtungslandschaften, Spielfeld.Landschaften(X, Y - 1, ObjektSpielfeld.Bodenschlacht).getID, True) >= 0 Then
                    Ausrichtungen += "+N"
                End If
            End If
            If X + 1 < Spielfeld.Breite Then
                If FindElement(Ausrichtungslandschaften, Spielfeld.Landschaften(X + 1, Y, ObjektSpielfeld.Bodenschlacht).getID, True) >= 0 Then
                    Ausrichtungen += "+O"
                End If
            End If
            If Y + 1 < Spielfeld.Höhe Then
                If FindElement(Ausrichtungslandschaften, Spielfeld.Landschaften(X, Y + 1, ObjektSpielfeld.Bodenschlacht).getID, True) >= 0 Then
                    Ausrichtungen += "+S"
                End If
            End If
            If X - 1 >= 0 Then
                If FindElement(Ausrichtungslandschaften, Spielfeld.Landschaften(X - 1, Y, ObjektSpielfeld.Bodenschlacht).getID, True) >= 0 Then
                    Ausrichtungen += "+W"
                End If
            End If
        End If
        Select Case ID
            Case "SEE"
                'Wir machen nichts
            Case "RIFF"
                Ausrichtungen = AddRandAusrichtung(X, Y, Ausrichtungen, Spielfeld)
            Case "RAUESEE"
                Ausrichtungen = AddRandAusrichtung(X, Y, Ausrichtungen, Spielfeld)
            Case "NEBEL"
                Ausrichtungen = AddRandAusrichtung(X, Y, Ausrichtungen, Spielfeld)
            Case Else
                If Ausrichtungen.Length <= 2 Then
                    Ausrichtungen = AddRandAusrichtung(X, Y, Ausrichtungen, Spielfeld)
                End If
        End Select
        Return Ausrichtungen
    End Function
    Public Function AddRandAusrichtung(ByVal X As Integer, ByVal Y As Integer, ByVal Ausrichtungen As String, ByVal Spielfeld As ObjektSpielfeld) As String
        If Y - 1 < 0 Then
            Ausrichtungen = "+N" + Ausrichtungen
        End If
        If X + 1 >= Spielfeld.Breite Then
            If Ausrichtungen.StartsWith("+N") Then
                If Ausrichtungen.Contains("+S") Then
                    Ausrichtungen = "+N+O" + Ausrichtungen.Remove(0, 2)
                ElseIf Ausrichtungen.Contains("+W") Then
                    Ausrichtungen = "+N+O" + Ausrichtungen.Remove(0, 2)
                Else
                    Ausrichtungen += "+O"
                End If
            Else
                Ausrichtungen = "+O" + Ausrichtungen
            End If
        End If
        If Y + 1 >= Spielfeld.Höhe Then
            If Ausrichtungen.StartsWith("+W") Then
                Ausrichtungen = "+S" + Ausrichtungen
            ElseIf Ausrichtungen.EndsWith("+W") Then
                Ausrichtungen = Ausrichtungen.Remove(Ausrichtungen.Length - 2) + "+S+W"
            Else
                Ausrichtungen += "+S"
            End If
        End If
        If X - 1 < 0 Then
            Ausrichtungen += "+W"
        End If
        Return Ausrichtungen
    End Function
    Public Function AusrichtungInvertieren(ByVal Ausrichtung As String) As String
        Ausrichtung = Ausrichtung.ToLower
        Dim N As Boolean = Ausrichtung.Contains("n")
        Dim O As Boolean = Ausrichtung.Contains("o")
        Dim S As Boolean = Ausrichtung.Contains("s")
        Dim W As Boolean = Ausrichtung.Contains("w")
        Dim Ergebnis As String = ""
        If Not N Then Ergebnis += "+N"
        If Not O Then Ergebnis += "+O"
        If Not S Then Ergebnis += "+S"
        If Not W Then Ergebnis += "+W"
        Return Ergebnis
    End Function
    Public Function AusrichtungVereinfachen(ByVal Ausrichtung As String, ByRef Rotation As Single) As String
        Rotation = 0
        If Not Ausrichtung = "" Then
            Select Case Ausrichtung.ToUpper
                Case "+N"
                    Rotation = 0
                    Ausrichtung = "+N"
                Case "+O"
                    Rotation = Math.PI / 2
                    Ausrichtung = "+N"
                Case "+S"
                    Rotation = Math.PI
                    Ausrichtung = "+N"
                Case "+W"
                    Rotation = Math.PI * 3 / 2
                    Ausrichtung = "+N"

                Case "+N+O"
                    Rotation = 0
                    Ausrichtung = "+N+O"
                Case "+O+S"
                    Rotation = Math.PI / 2
                    Ausrichtung = "+N+O"
                Case "+S+W"
                    Rotation = Math.PI
                    Ausrichtung = "+N+O"
                Case "+N+W"
                    Rotation = Math.PI * 3 / 2
                    Ausrichtung = "+N+O"

                Case "+N+S"
                    Rotation = 0
                    Ausrichtung = "+N+S"
                Case "+O+W"
                    Rotation = Math.PI / 2
                    Ausrichtung = "+N+S"

                Case "+N+O+S"
                    Rotation = 0
                    Ausrichtung = "+N+O+S"
                Case "+O+S+W"
                    Rotation = Math.PI / 2
                    Ausrichtung = "+N+O+S"
                Case "+N+S+W"
                    Rotation = Math.PI
                    Ausrichtung = "+N+O+S"
                Case "+N+O+W"
                    Rotation = Math.PI * 3 / 2
                    Ausrichtung = "+N+O+S"

                Case "+N+O+S+W"
                    Rotation = 0
                    Ausrichtung = "+N+O+S+W"
            End Select
        End If
        Return Ausrichtung
    End Function
    ''' <summary>
    ''' Ist jetzt eine Extra funktion, die nur das "+N+S+W" usw. zurückgibt, damit ichs fürs 3D verwenden kann. Vereinfacht heißt, dass nicht mehr +O zurückgegeben wird, sondern +N und eine Rotation um 90°
    ''' </summary>
    ''' <param name="X"></param>
    ''' <param name="Y"></param>
    ''' <param name="Spielfeld"></param>
    ''' <returns></returns>
    ''' <remarks></remarks>
    Public Function getAusrichtungVereinfacht(ByVal X As Integer, ByVal Y As Integer, ByVal Spielfeld As ObjektSpielfeld, ByRef Rotation As Single) As String
        Dim Ausrichtung As String = getAusrichtung(X, Y, Spielfeld)
        Return AusrichtungVereinfachen(Ausrichtung, Rotation)
    End Function
    Public Overridable Function BildID(ByVal X As Integer, ByVal Y As Integer, ByVal Spielfeld As ObjektSpielfeld) As Integer
        Dim Ausrichtungen As String = getAusrichtung(X, Y, Spielfeld)
        If Ausrichtungen = "" Then
            If Normal < 0 Then
                Return -1
            Else
                If ID = "EBENE" Then
                    Select Case My.Settings.TerrainStyle
                        Case TerrainStyle.AdvanceWarsDC, TerrainStyle.CommanderWars2
                            If Zufallszahl(0, 10) > 9 Then
                                Return Zufallszahl(0, Normal)
                            Else
                                Return Zufallszahl(0, 12)
                            End If
                        Case Else
                            Return Zufallszahl(0, Normal)
                    End Select
                Else
                    Return Zufallszahl(0, Normal)
                End If
            End If
        Else
            If Ausrichtungen.StartsWith("+") Then
                Ausrichtungen = Ausrichtungen.Remove(0, 1)
            End If
            Dim Stelle As Integer = FindElement(Ausrichtung, Ausrichtungen, True)
            If Stelle < 0 Then
                If Normal < 0 Then
                    Return -1
                Else
                    If ID = "EBENE" Then
                        Select Case My.Settings.TerrainStyle
                            Case TerrainStyle.AdvanceWarsDC, TerrainStyle.CommanderWars2
                                If Zufallszahl(0, 10) > 9 Then
                                    Return Zufallszahl(0, Normal)
                                Else
                                    Return Zufallszahl(0, 12)
                                End If
                            Case Else
                                Return Zufallszahl(0, Normal)
                        End Select
                    Else
                        Return Zufallszahl(0, Normal)
                    End If
                End If
            Else
                Return Stelle
            End If
        End If
    End Function
    Public Function ÜbergangsID(ByVal X As Integer, ByVal Y As Integer, ByVal Spielfeld As ObjektSpielfeld) As Integer()
        Dim Rückgabe() As Integer = {}
        If IsNothing(Spielfeld) = False And Not Spielfeld.Landschaften(Spielfeld.Breite - 1, Spielfeld.Höhe - 1, ObjektSpielfeld.Bodenschlacht) Is Nothing Then
            If ÜbergangsModus = Übergangsmodi.Keiner Then
                Return Rückgabe
            Else
                If ÜbergangsModus = Übergangsmodi.VierAngrenzenden Or ÜbergangsModus = Übergangsmodi.NichtVierAngrenzenden Then
                    Dim Ausrichtung As String = ""
                    For I = 0 To 3
                        Select Case I
                            Case 0
                                Ausrichtung = "N"
                                Y -= 1
                            Case 1
                                Ausrichtung = "O"
                                Y += 1
                                X += 1
                            Case 2
                                Ausrichtung = "S"
                                X -= 1
                                Y += 1
                            Case 3
                                Ausrichtung = "W"
                                Y -= 1
                                X -= 1
                        End Select
                        If X >= 0 And Y >= 0 And X < Spielfeld.Breite And Y < Spielfeld.Höhe Then
                            If ÜbergangsModus = Übergangsmodi.VierAngrenzenden Then
                                If FindElement(ÜbergangsAusrichtungslandschaften, Spielfeld.Landschaften(X, Y, ObjektSpielfeld.Bodenschlacht).getID, True) >= 0 Then
                                    Array.Resize(Rückgabe, Rückgabe.Length + 1)
                                    Rückgabe(Rückgabe.Length - 1) = FindElement(Übergangfunktion, Ausrichtung)
                                End If
                            Else
                                If FindElement(ÜbergangsAusrichtungslandschaften, Spielfeld.Landschaften(X, Y, ObjektSpielfeld.Bodenschlacht).getID, True) < 0 Then
                                    Array.Resize(Rückgabe, Rückgabe.Length + 1)
                                    Rückgabe(Rückgabe.Length - 1) = FindElement(Übergangfunktion, Ausrichtung)
                                End If
                            End If
                        End If
                    Next
                ElseIf ÜbergangsModus = Übergangsmodi.NurEcken Or ÜbergangsModus = Übergangsmodi.NichtNurEcken Then
                    If Y - 1 >= 0 And X + 1 < Spielfeld.Breite Then
                        If ÜbergangsModus = Übergangsmodi.NurEcken Then
                            If FindElement(ÜbergangsAusrichtungslandschaften, Spielfeld.Landschaften(X, Y - 1, ObjektSpielfeld.Bodenschlacht).getID, True) < 0 And FindElement(ÜbergangsAusrichtungslandschaften, Spielfeld.Landschaften(X + 1, Y, ObjektSpielfeld.Bodenschlacht).getID, True) < 0 Then
                                If FindElement(ÜbergangsAusrichtungslandschaften, Spielfeld.Landschaften(X + 1, Y - 1, ObjektSpielfeld.Bodenschlacht).getID, True) >= 0 Then
                                    Array.Resize(Rückgabe, Rückgabe.Length + 1)
                                    Rückgabe(Rückgabe.Length - 1) = FindElement(Übergangfunktion, "NO")
                                End If
                            End If
                        Else
                            If FindElement(ÜbergangsAusrichtungslandschaften, Spielfeld.Landschaften(X, Y - 1, ObjektSpielfeld.Bodenschlacht).getID, True) >= 0 And FindElement(ÜbergangsAusrichtungslandschaften, Spielfeld.Landschaften(X + 1, Y, ObjektSpielfeld.Bodenschlacht).getID, True) >= 0 Then
                                If FindElement(ÜbergangsAusrichtungslandschaften, Spielfeld.Landschaften(X + 1, Y - 1, ObjektSpielfeld.Bodenschlacht).getID, True) < 0 Then
                                    Array.Resize(Rückgabe, Rückgabe.Length + 1)
                                    Rückgabe(Rückgabe.Length - 1) = FindElement(Übergangfunktion, "NO")
                                End If
                            End If
                        End If
                    End If
                    If Y + 1 < Spielfeld.Höhe And X + 1 < Spielfeld.Breite Then
                        If ÜbergangsModus = Übergangsmodi.NurEcken Then
                            If FindElement(ÜbergangsAusrichtungslandschaften, Spielfeld.Landschaften(X, Y + 1, ObjektSpielfeld.Bodenschlacht).getID, True) < 0 And FindElement(ÜbergangsAusrichtungslandschaften, Spielfeld.Landschaften(X + 1, Y, ObjektSpielfeld.Bodenschlacht).getID, True) < 0 Then
                                If FindElement(ÜbergangsAusrichtungslandschaften, Spielfeld.Landschaften(X + 1, Y + 1, ObjektSpielfeld.Bodenschlacht).getID, True) >= 0 Then
                                    Array.Resize(Rückgabe, Rückgabe.Length + 1)
                                    Rückgabe(Rückgabe.Length - 1) = FindElement(Übergangfunktion, "OS")
                                End If
                            End If
                        Else
                            If FindElement(ÜbergangsAusrichtungslandschaften, Spielfeld.Landschaften(X, Y + 1, ObjektSpielfeld.Bodenschlacht).getID, True) >= 0 And FindElement(ÜbergangsAusrichtungslandschaften, Spielfeld.Landschaften(X + 1, Y, ObjektSpielfeld.Bodenschlacht).getID, True) >= 0 Then
                                If FindElement(ÜbergangsAusrichtungslandschaften, Spielfeld.Landschaften(X + 1, Y + 1, ObjektSpielfeld.Bodenschlacht).getID, True) < 0 Then
                                    Array.Resize(Rückgabe, Rückgabe.Length + 1)
                                    Rückgabe(Rückgabe.Length - 1) = FindElement(Übergangfunktion, "OS")
                                End If
                            End If
                        End If
                    End If
                    If Y + 1 < Spielfeld.Höhe And X - 1 >= 0 Then
                        If ÜbergangsModus = Übergangsmodi.NurEcken Then
                            If FindElement(ÜbergangsAusrichtungslandschaften, Spielfeld.Landschaften(X, Y + 1, ObjektSpielfeld.Bodenschlacht).getID, True) < 0 And FindElement(ÜbergangsAusrichtungslandschaften, Spielfeld.Landschaften(X - 1, Y, ObjektSpielfeld.Bodenschlacht).getID, True) < 0 Then
                                If FindElement(ÜbergangsAusrichtungslandschaften, Spielfeld.Landschaften(X + 1, Y - 1, ObjektSpielfeld.Bodenschlacht).getID, True) >= 0 Then
                                    Array.Resize(Rückgabe, Rückgabe.Length + 1)
                                    Rückgabe(Rückgabe.Length - 1) = FindElement(Übergangfunktion, "SW")
                                End If
                            End If
                        Else
                            If FindElement(ÜbergangsAusrichtungslandschaften, Spielfeld.Landschaften(X, Y + 1, ObjektSpielfeld.Bodenschlacht).getID, True) >= 0 And FindElement(ÜbergangsAusrichtungslandschaften, Spielfeld.Landschaften(X - 1, Y, ObjektSpielfeld.Bodenschlacht).getID, True) >= 0 Then
                                If FindElement(ÜbergangsAusrichtungslandschaften, Spielfeld.Landschaften(X - 1, Y + 1, ObjektSpielfeld.Bodenschlacht).getID, True) < 0 Then
                                    Array.Resize(Rückgabe, Rückgabe.Length + 1)
                                    Rückgabe(Rückgabe.Length - 1) = FindElement(Übergangfunktion, "SW")
                                End If
                            End If
                        End If
                    End If
                    If Y - 1 >= 0 And X - 1 >= 0 Then
                        If ÜbergangsModus = Übergangsmodi.NurEcken Then
                            If FindElement(ÜbergangsAusrichtungslandschaften, Spielfeld.Landschaften(X, Y - 1, ObjektSpielfeld.Bodenschlacht).getID, True) < 0 And FindElement(ÜbergangsAusrichtungslandschaften, Spielfeld.Landschaften(X - 1, Y, ObjektSpielfeld.Bodenschlacht).getID, True) < 0 Then
                                If FindElement(ÜbergangsAusrichtungslandschaften, Spielfeld.Landschaften(X - 1, Y - 1, ObjektSpielfeld.Bodenschlacht).getID, True) >= 0 Then
                                    Array.Resize(Rückgabe, Rückgabe.Length + 1)
                                    Rückgabe(Rückgabe.Length - 1) = FindElement(Übergangfunktion, "NW")
                                End If
                            End If
                        Else
                            If FindElement(ÜbergangsAusrichtungslandschaften, Spielfeld.Landschaften(X, Y - 1, ObjektSpielfeld.Bodenschlacht).getID, True) >= 0 And FindElement(ÜbergangsAusrichtungslandschaften, Spielfeld.Landschaften(X - 1, Y, ObjektSpielfeld.Bodenschlacht).getID, True) >= 0 Then
                                If FindElement(ÜbergangsAusrichtungslandschaften, Spielfeld.Landschaften(X - 1, Y - 1, ObjektSpielfeld.Bodenschlacht).getID, True) < 0 Then
                                    Array.Resize(Rückgabe, Rückgabe.Length + 1)
                                    Rückgabe(Rückgabe.Length - 1) = FindElement(Übergangfunktion, "NW")
                                End If
                            End If
                        End If
                    End If
                ElseIf ÜbergangsModus = Übergangsmodi.Strand Then
                    If Y - 1 >= 0 Then
                        If Spielfeld.Landschaften(X, Y - 1, ObjektSpielfeld.Bodenschlacht).getID = "STRAND" Then
                            If X - 1 >= 0 Then
                                If Array.IndexOf(ÜbergangsAusrichtungslandschaften, Spielfeld.Landschaften(X - 1, Y - 1, ObjektSpielfeld.Bodenschlacht).getID) >= 0 Then
                                    Array.Resize(Rückgabe, Rückgabe.Length + 1)
                                    Rückgabe(Rückgabe.Length - 1) = FindElement(Übergangfunktion, "WN")
                                End If
                            ElseIf Not ID = "SEE" Then
                                Array.Resize(Rückgabe, Rückgabe.Length + 1)
                                Rückgabe(Rückgabe.Length - 1) = FindElement(Übergangfunktion, "WN")
                            End If
                            If X + 1 < Spielfeld.Breite Then
                                If Array.IndexOf(ÜbergangsAusrichtungslandschaften, Spielfeld.Landschaften(X + 1, Y - 1, ObjektSpielfeld.Bodenschlacht).getID) >= 0 Then
                                    Array.Resize(Rückgabe, Rückgabe.Length + 1)
                                    Rückgabe(Rückgabe.Length - 1) = FindElement(Übergangfunktion, "ON")
                                End If
                            ElseIf Not ID = "SEE" Then
                                Array.Resize(Rückgabe, Rückgabe.Length + 1)
                                Rückgabe(Rückgabe.Length - 1) = FindElement(Übergangfunktion, "ON")
                            End If
                        End If
                    End If
                    If Y + 1 < Spielfeld.Höhe Then
                        If Spielfeld.Landschaften(X, Y + 1, ObjektSpielfeld.Bodenschlacht).getID = "STRAND" Then
                            If X - 1 >= 0 Then
                                If Array.IndexOf(ÜbergangsAusrichtungslandschaften, Spielfeld.Landschaften(X - 1, Y + 1, ObjektSpielfeld.Bodenschlacht).getID) >= 0 Then
                                    Array.Resize(Rückgabe, Rückgabe.Length + 1)
                                    Rückgabe(Rückgabe.Length - 1) = FindElement(Übergangfunktion, "WS")
                                End If
                            ElseIf Not ID = "SEE" Then
                                Array.Resize(Rückgabe, Rückgabe.Length + 1)
                                Rückgabe(Rückgabe.Length - 1) = FindElement(Übergangfunktion, "WS")
                            End If
                            If X + 1 < Spielfeld.Breite Then
                                If Array.IndexOf(ÜbergangsAusrichtungslandschaften, Spielfeld.Landschaften(X + 1, Y + 1, ObjektSpielfeld.Bodenschlacht).getID) >= 0 Then
                                    Array.Resize(Rückgabe, Rückgabe.Length + 1)
                                    Rückgabe(Rückgabe.Length - 1) = FindElement(Übergangfunktion, "OS")
                                End If
                            ElseIf Not ID = "SEE" Then
                                Array.Resize(Rückgabe, Rückgabe.Length + 1)
                                Rückgabe(Rückgabe.Length - 1) = FindElement(Übergangfunktion, "OS")
                            End If
                        End If
                    End If
                    If X - 1 >= 0 Then
                        If Spielfeld.Landschaften(X - 1, Y, ObjektSpielfeld.Bodenschlacht).getID = "STRAND" Then
                            If Y - 1 >= 0 Then
                                If Array.IndexOf(ÜbergangsAusrichtungslandschaften, Spielfeld.Landschaften(X - 1, Y - 1, ObjektSpielfeld.Bodenschlacht).getID) >= 0 Then
                                    Array.Resize(Rückgabe, Rückgabe.Length + 1)
                                    Rückgabe(Rückgabe.Length - 1) = FindElement(Übergangfunktion, "NW")
                                End If
                            ElseIf Not ID = "SEE" Then
                                Array.Resize(Rückgabe, Rückgabe.Length + 1)
                                Rückgabe(Rückgabe.Length - 1) = FindElement(Übergangfunktion, "NW")
                            End If
                            If Y + 1 < Spielfeld.Höhe Then
                                If Array.IndexOf(ÜbergangsAusrichtungslandschaften, Spielfeld.Landschaften(X - 1, Y + 1, ObjektSpielfeld.Bodenschlacht).getID) >= 0 Then
                                    Array.Resize(Rückgabe, Rückgabe.Length + 1)
                                    Rückgabe(Rückgabe.Length - 1) = FindElement(Übergangfunktion, "SW")
                                End If
                            ElseIf Not ID = "SEE" Then
                                Array.Resize(Rückgabe, Rückgabe.Length + 1)
                                Rückgabe(Rückgabe.Length - 1) = FindElement(Übergangfunktion, "SW")
                            End If
                        End If
                    End If
                    If X + 1 < Spielfeld.Breite Then
                        If Spielfeld.Landschaften(X + 1, Y, ObjektSpielfeld.Bodenschlacht).getID = "STRAND" Then
                            If Y - 1 >= 0 Then
                                If Array.IndexOf(ÜbergangsAusrichtungslandschaften, Spielfeld.Landschaften(X + 1, Y - 1, ObjektSpielfeld.Bodenschlacht).getID) >= 0 Then
                                    Array.Resize(Rückgabe, Rückgabe.Length + 1)
                                    Rückgabe(Rückgabe.Length - 1) = FindElement(Übergangfunktion, "NO")
                                End If
                            ElseIf Not ID = "SEE" Then
                                Array.Resize(Rückgabe, Rückgabe.Length + 1)
                                Rückgabe(Rückgabe.Length - 1) = FindElement(Übergangfunktion, "NO")
                            End If
                            If Y + 1 < Spielfeld.Höhe Then
                                If Array.IndexOf(ÜbergangsAusrichtungslandschaften, Spielfeld.Landschaften(X + 1, Y + 1, ObjektSpielfeld.Bodenschlacht).getID) >= 0 Then
                                    Array.Resize(Rückgabe, Rückgabe.Length + 1)
                                    Rückgabe(Rückgabe.Length - 1) = FindElement(Übergangfunktion, "SO")
                                End If
                            ElseIf Not ID = "SEE" Then
                                Array.Resize(Rückgabe, Rückgabe.Length + 1)
                                Rückgabe(Rückgabe.Length - 1) = FindElement(Übergangfunktion, "SO")
                            End If
                        End If
                    End If
                End If
            End If
        End If
        Return Rückgabe
    End Function

    Public Sub Malen3D(ByVal p_MatCube As Microsoft.DirectX.Matrix, ByVal ID As String, Optional ByVal Landschaft As ObjektLandschaft = Nothing)
        For i = 0 To Objektverwalter.LandschaftenBilder.Length - 1
            If Objektverwalter.LandschaftenBilder(i).ID.ToUpper = ID.ToUpper Then
                Objektverwalter.LandschaftenBilder(i).Malen3D(p_MatCube, Landschaft)
                Exit Sub
            End If
        Next
    End Sub

    ''' <summary>
    ''' Gibt die Position zurück, wo Einheiten hingemalt werden sollen. (Meistens 0.5 in X und Z-Richtung)
    ''' </summary>
    ''' <param name="Pos"> Die Art wie sie stehen soll. "LAND", "LUFT" oder "WASSER"</param>
    ''' <returns></returns>
    ''' <remarks></remarks>
    Public Overridable Function getFigurPos(ByVal Pos As Positionsarten) As Vector3
        Select Case Pos
            Case Positionsarten.Boden
                Return New Vector3(0.5, 0, 0.5)
            Case Positionsarten.Luft
                Return New Vector3(0.5, 1, 0.5)
            Case Positionsarten.Wasser
                Return New Vector3(0.5, 0, 0.5)
            Case Else
                Return New Vector3(0.5, 0, 0.5)
        End Select
    End Function
    Public MustOverride Sub Malen3D(ByVal p_MatCube As Microsoft.DirectX.Matrix, ByVal Landschaft As ObjektLandschaft)
    Public MustOverride Sub Ini3D()
    Public MustOverride Sub Tick()
    Public Overridable Function getMesh() As Mesh
        Return Nothing
    End Function

End Class
